function Iterator( elements, direction ) {
	/**
	* Collection of element over which iterator is beeing created.
	*
	* @private
	* @property elements
	* @type     List
	* @Cyan  null
	*/
    this.elements = elements;

    /**
    * Current index of iterator pointer into element of wrapped collection.
    *
    * @private
    * @property index
    * @type     Number
    * @Cyan  -1
    */
    this.index = -1;

    /**
    * Forward iterator (direction) flag
    *
    * @private
    * @property  forwardIterator
    * @type      {Boolean}
    * @Cyan   true
    */
    this.forwardIterator = true;

    if (Iterator.arguments.length === 2) {

        if (!Iterator.arguments[1]) {
        // reversed iterator
            this.index = this.elements.length;
        }

        // set direction flag
        this.forwardIterator = Iterator.arguments[1]; 
    }
}


    /**
    * Returns true if the iteration has more elements.
    *
    * @public
    * @method hasNext
    * @return {Boolean} true / false
    */
    Iterator.prototype.hasNext = function() {

        if (this.index < this.elements.length-1) {
                return true;
        }
    };

    /**
    * Returns true if the iteration has more 'previous' elements.
    *
    * @public
    * @method hasPrev
    * @return {Boolean} true / false
    */
    Iterator.prototype.hasPrev = function() {
        
        if (this.index > 0) {
            return true;
        }
    };

    /**
     * Returns the next element in the iteration.
     *
     * @public
     * @method next
     * @return {Objec} next element of collection or null if no more elements available
     */
    Iterator.prototype.next = function() {

        if (this.index < this.elements.length-1) {
                return this.elements[ ++this.index ];
        }
        //
        return null;
    };

    /**
     * Returns the previous element in the collection.
     *
     * @public
     * @method prev
     * @return {Object} previous element of collection or null if no more elements available
     */
    Iterator.prototype.prev = function() {

        if (this.index > 0) {
            return this.elements[ --this.index ];
        }
        //
        return null;
    };

    /**
    * Removes from the underlying collection the last element returned by the iterator.
    *
    * @public
    * @method remove
    */
    Iterator.prototype.remove = function() {

        if (this.index < this.elements.length) {
            this.elements.splice(this.index, 1);

            if (this.isForward()) {
                this.index--; // forward itr.
            }
            else {
                this.index++; // backward itr.
            }
        }
    };

    /**
    * Resets iterator, sets index value to -1
    *
    * @public
    * @method reset
    */
    Iterator.prototype.reset = function() {

        this.index = -1;
    };

    /**
     * Returns index of current element within this collection.
     *
     * @public
     * @method getIndex
     * @return {Number} index value
     */
    Iterator.prototype.getIndex = function() {

        return this.index;
    };

    /**
    * Returns iterator direction flag. True for forward, false for backward iterator.
    *
    * @public
    * @method  isForward
    * @return  {Boolean}
    */
    Iterator.prototype.isForward = function() {

        return this.forwardIterator;
    };




